{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "77ea2ac8",
   "metadata": {},
   "source": [
    "# 实现深层神经网络\n",
    "\n",
    "本章我们将编码完成全连接神经网络，并使用CIFAR-10数据集进行测试，在本章练习中我们将完成：\n",
    "- 1.仿射层传播\n",
    "- 2.ReLU层传播\n",
    "- 3.组合单层神经元\n",
    "- 4.实现浅层全连接神经网络\n",
    "- 5.实现深层全连接神经网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e9e4ae50",
   "metadata": {},
   "outputs": [],
   "source": [
    "# -*- coding: utf-8 -*-\n",
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from classifiers.chapter3 import *\n",
    "from utils import *\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] =(10.0, 8.0) # 设置默认绘图尺寸\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "  #计算相对错误\n",
    "  return np.max(np.abs(x - y) /(np.maximum(1e-8, np.abs(x) + np.abs(y))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e29c746f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train:  (49000, 3, 32, 32)\n",
      "y_train:  (49000,)\n",
      "X_val:  (1000, 3, 32, 32)\n",
      "y_val:  (1000,)\n",
      "X_test:  (1000, 3, 32, 32)\n",
      "y_test:  (1000,)\n"
     ]
    }
   ],
   "source": [
    "# 将CIFAR10数据集的导入，切片，预处理操作进行封装\n",
    "data = get_CIFAR10_data()  #获取数据\n",
    "# 训练数据\n",
    "X_train =data['X_train']\n",
    "y_train =data['y_train']\n",
    "# 验证数据\n",
    "X_val = data['X_val']\n",
    "y_val = data['y_val']\n",
    "# 测试数据\n",
    "X_test = data['X_test']\n",
    "y_test = data['y_test']\n",
    "for k, v in data.items():\n",
    "    print('%s: ' % k, v.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57ca7eaa",
   "metadata": {},
   "source": [
    "## 仿射层前向传播\n",
    "\n",
    "仿射（affine）传播就是将各个输入特征进行加权求和，如果下一层有m个神经元，那就相当于线性代数中的m组线性方程式。\n",
    "\n",
    "进行测试："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "fd894b7e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "测试 affine_forward 函数:\n",
      "误差:  9.769847728806635e-10\n"
     ]
    }
   ],
   "source": [
    "# 测试affine_forward 函数\n",
    "# np.linspaces，规定起点、终点（包含）、返回array的长度，返回一个两端点间数值平均分布的array。\n",
    "num_inputs = 2\n",
    "input_shape =(4, 5, 6)\n",
    "output_dim = 3 #输出维度\n",
    "\n",
    "# 2*4*5*6\n",
    "input_size = num_inputs * np.prod(input_shape)\n",
    "# 3*4*5*6\n",
    "weight_size = output_dim * np.prod(input_shape)\n",
    "\n",
    "# 初始化输入参数\n",
    "x = np.linspace(-0.1, 0.5, num=input_size).reshape(num_inputs, *input_shape)\n",
    "w = np.linspace(-0.2, 0.3, num=weight_size).reshape(np.prod(input_shape), output_dim)\n",
    "b = np.linspace(-0.3, 0.1, num=output_dim)\n",
    "\n",
    "# 测试affine_forward函数\n",
    "out, _ = affine_forward(x, w, b)\n",
    "correct_out = np.array([[ 1.49834967,  1.70660132,  1.91485297],\n",
    "                        [ 3.25553199,  3.5141327,   3.77273342]])\n",
    "\n",
    "# 比较你的实现结果和正确结果。该误差应该小于1e-9。\n",
    "print('测试 affine_forward 函数:')\n",
    "print('误差: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87af9dc3",
   "metadata": {},
   "source": [
    "## 仿射层反向传播\n",
    "\n",
    "在前向传播中，实现的启示就是out=x1*w1+x2*w2+b这个函数，那仿射层的反向传播，其实就是将x，w，b各自对应的梯度求出即可。需要注意的是，在缓存中我们存储的是原始数据的四维图像数据。因此，同前向传播一样，首先将数据转换为二维数据后，再进行求解。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "53229838",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "测试 affine_backward 函数:\n",
      "dx 误差:  8.246429923021287e-11\n",
      "dw 误差:  9.774704022249044e-11\n",
      "db 误差:  1.8324937594438097e-11\n"
     ]
    }
   ],
   "source": [
    "# 测试 affine_backward 函数\n",
    "from utils.gradient_check import *\n",
    "\n",
    "x = np.random.randn(10, 2, 3)\n",
    "w = np.random.randn(6, 5)\n",
    "b = np.random.randn(5)\n",
    "dout = np.random.randn(10, 5)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "_, cache = affine_forward(x, w, b)\n",
    "dx, dw, db = affine_backward(dout, cache)\n",
    "\n",
    "# 相对误差应该小于1e-10\n",
    "print('测试 affine_backward 函数:')\n",
    "print('dx 误差: ', rel_error(dx_num, dx))\n",
    "print('dw 误差: ', rel_error(dw_num, dw))\n",
    "print('db 误差: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "253478af",
   "metadata": {},
   "source": [
    "## ReLU层前向传播\n",
    "\n",
    "ReLU激活函数的公式为max(0, x)，我们直接使用NumPy提供的内置公式即可。实现 relu_forward 激活函数的前向传播，并使用下列代码进行测试:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4c103517",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "测试 relu_forward 函数:\n",
      "误差:  4.999999798022158e-08\n"
     ]
    }
   ],
   "source": [
    "# 测试relu_forward 函数\n",
    "\n",
    "x = np.linspace(-0.5, 0.5, num=12).reshape(3, 4)\n",
    "\n",
    "out, _ = relu_forward(x)\n",
    "correct_out = np.array([[ 0.,          0.,          0.,          0.,        ],\n",
    "                        [ 0.,          0.,          0.04545455,  0.13636364,],\n",
    "                        [ 0.22727273,  0.31818182,  0.40909091,  0.5,       ]])\n",
    "\n",
    "# 比较输出结果. 其误差大约为 1e-8\n",
    "print('测试 relu_forward 函数:')\n",
    "print('误差: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cdf9c986",
   "metadata": {},
   "source": [
    "## ReLU层反向传播\n",
    "\n",
    "实现 relu_backward函数并使用数值梯度进行检验："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4cbc69ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "测试 relu_backward 函数:\n",
      "dx 误差:  3.275616534549067e-12\n"
     ]
    }
   ],
   "source": [
    "x = np.random.randn(10, 10)\n",
    "dout = np.random.randn(*x.shape)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: relu_forward(x)[0], x, dout)\n",
    "\n",
    "_, cache = relu_forward(x)\n",
    "dx = relu_backward(dout, cache)\n",
    "\n",
    "# 其相对误差大约为1e-12\n",
    "print('测试 relu_backward 函数:')\n",
    "print('dx 误差: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f27a46ca",
   "metadata": {},
   "source": [
    "## 完整的神经元层\n",
    "\n",
    "接下来我们将上述的affine传播，和ReLU传播组合在一起，形成一层完整的神经元层。\n",
    "\n",
    "在你实现affine_relu_forward和affine_relu_backward函数之后，运行下面的代码进行梯度检验："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "c93863d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "测试 ReLU神经元相对误差:\n",
      "dx 误差:  3.201929439745625e-11\n",
      "dw 误差:  3.219935510377178e-09\n",
      "db 误差:  3.2756942145383654e-12\n"
     ]
    }
   ],
   "source": [
    "#初始化。\n",
    "x = np.random.randn(2, 3, 4)\n",
    "w = np.random.randn(12, 10)\n",
    "b = np.random.randn(10)\n",
    "dout = np.random.randn(2, 10)\n",
    "\n",
    "#执行ReLU，获取分析梯度。\n",
    "out, cache = affine_relu_forward(x, w, b)\n",
    "dx, dw, db = affine_relu_backward(dout, cache)\n",
    "\n",
    "#获取数值梯度。\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_relu_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_relu_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_relu_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "#比较相对误差。\n",
    "print('测试 ReLU神经元相对误差:')\n",
    "print('dx 误差: ', rel_error(dx_num, dx))\n",
    "print('dw 误差: ', rel_error(dw_num, dw))\n",
    "print('db 误差: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcdf21eb",
   "metadata": {},
   "source": [
    "## 输出层：Softmax\n",
    "\n",
    "运行下列代码以确认我们的实现是正确的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "0bae2c0b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "测试 softmax_loss:\n",
      "loss:  2.302394306232496\n",
      "dx error:  8.016008070036267e-09\n"
     ]
    }
   ],
   "source": [
    "num_classes, num_inputs = 10, 50\n",
    "x = 0.001 * np.random.randn(num_inputs, num_classes)\n",
    "\n",
    "y = np.random.randint(num_classes, size=num_inputs)\n",
    "dx_num = eval_numerical_gradient(lambda x: softmax_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = softmax_loss(x, y)\n",
    "\n",
    "# 测试 softmax_loss 函数. 损失值大约为 2.3 dx 误差大约为 1e-8\n",
    "print('\\n测试 softmax_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a84114e7",
   "metadata": {},
   "source": [
    "## 浅层神经网络\n",
    "\n",
    "现在我们将实现浅层全连接神经网络，打开chapter3\\shallow_layer_net.py文件，阅读内容完成相应任务后，执行下面代码进行验证。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "9516a283",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "测试初始化 ... \n",
      "测试前向传播过程 ... \n",
      "测试训练损失(正则化0.1)\n",
      "梯度检验，正则化系数 =  0.0\n",
      "W1 相对误差: 1.52e-08\n",
      "W2 相对误差: 3.48e-10\n",
      "b1 相对误差: 6.55e-09\n",
      "b2 相对误差: 4.33e-10\n",
      "梯度检验，正则化系数 =  0.7\n",
      "W1 相对误差: 8.18e-07\n",
      "W2 相对误差: 2.85e-08\n",
      "b1 相对误差: 1.09e-09\n",
      "b2 相对误差: 9.09e-10\n"
     ]
    }
   ],
   "source": [
    "N, D, H, C = 3, 5, 50, 7\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=N)\n",
    "\n",
    "std = 1e-2\n",
    "model = ShallowLayerNet(input_dim=D, hidden_dim=H, num_classes=C, weight_scale=std)\n",
    "\n",
    "print('测试初始化 ... ')\n",
    "W1_std = abs(model.params['W1'].std() - std)\n",
    "b1 = model.params['b1']\n",
    "W2_std = abs(model.params['W2'].std() - std)\n",
    "b2 = model.params['b2']\n",
    "# assert(W1_std < std / 10, '第一层权重初始化有问题')\n",
    "# assert(np.all(b1 == 0), '第一层偏置初始化有问题')\n",
    "# assert(W2_std < std / 10, '第二层权重初始化有问题')\n",
    "# assert(np.all(b2 == 0), '第二层偏置初始化有问题')\n",
    "\n",
    "print('测试前向传播过程 ... ')\n",
    "model.params['W1'] = np.linspace(-0.7, 0.3, num=D*H).reshape(D, H)\n",
    "model.params['b1'] = np.linspace(-0.1, 0.9, num=H)\n",
    "model.params['W2'] = np.linspace(-0.3, 0.4, num=H*C).reshape(H, C)\n",
    "model.params['b2'] = np.linspace(-0.9, 0.1, num=C)\n",
    "X = np.linspace(-5.5, 4.5, num=N*D).reshape(D, N).T\n",
    "scores = model.loss(X)\n",
    "correct_scores = np.asarray(\n",
    "    [[11.53165108,    12.2917344,     13.05181771,    13.81190102,    14.57198434, 15.33206765,    16.09215096],\n",
    "     [12.05769098,    12.74614105,    13.43459113,    14.1230412,     14.81149128, 15.49994135,    16.18839143],\n",
    "     [12.58373087,    13.20054771,    13.81736455,    14.43418138,    15.05099822, 15.66781506,    16.2846319 ]])\n",
    "scores_diff = np.abs(scores - correct_scores).sum()\n",
    "# assert(scores_diff < 1e-6, '前向传播有问题')\n",
    "\n",
    "# print('测试训练损失(无正则化)')\n",
    "y = np.asarray([0, 5, 1])\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 3.4702243556\n",
    "# assert(abs(loss - correct_loss) < 1e-10, '训练阶段的损失值(无正则化)有问题')\n",
    "\n",
    "print('测试训练损失(正则化0.1)')\n",
    "model.reg = 1.0\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 26.5948426952\n",
    "# assert(abs(loss - correct_loss) < 1e-10, '训练阶段的损失值(有正则化)有问题')\n",
    "\n",
    "for reg in [0.0, 0.7]:\n",
    "    print('梯度检验，正则化系数 = ', reg)\n",
    "    model.reg = reg\n",
    "    loss, grads = model.loss(X, y)\n",
    "\n",
    "    for name in sorted(grads):\n",
    "        f = lambda _: model.loss(X, y)[0]\n",
    "        grad_num = eval_numerical_gradient(f, model.params[name], verbose=False)\n",
    "        print('%s 相对误差: %.2e' %(name, rel_error(grad_num, grads[name])) )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "865857be",
   "metadata": {},
   "source": [
    "## 训练浅层全连接网络\n",
    "\n",
    "阅读 ShallowLayerNet.train()以及predict()函数，确保自己了解整个流程"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "cc83dfd3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "迭代次数 0 / 2000: 损失值 2.393552\n",
      "迭代次数 100 / 2000: 损失值 1.841475\n",
      "迭代次数 200 / 2000: 损失值 1.806116\n",
      "迭代次数 300 / 2000: 损失值 1.681771\n",
      "迭代次数 400 / 2000: 损失值 1.610647\n",
      "迭代次数 500 / 2000: 损失值 1.602736\n",
      "迭代次数 600 / 2000: 损失值 1.611873\n",
      "迭代次数 700 / 2000: 损失值 1.637565\n",
      "迭代次数 800 / 2000: 损失值 1.608373\n",
      "迭代次数 900 / 2000: 损失值 1.531719\n",
      "迭代次数 1000 / 2000: 损失值 1.468017\n",
      "迭代次数 1100 / 2000: 损失值 1.395518\n",
      "迭代次数 1200 / 2000: 损失值 1.465631\n",
      "迭代次数 1300 / 2000: 损失值 1.385197\n",
      "迭代次数 1400 / 2000: 损失值 1.477168\n",
      "迭代次数 1500 / 2000: 损失值 1.437521\n",
      "迭代次数 1600 / 2000: 损失值 1.497306\n",
      "迭代次数 1700 / 2000: 损失值 1.462852\n",
      "迭代次数 1800 / 2000: 损失值 1.439107\n",
      "迭代次数 1900 / 2000: 损失值 1.401284\n",
      "最终验证正确率:  0.532\n",
      "历史最佳验证正确率:  0.534\n"
     ]
    }
   ],
   "source": [
    "input_size = 32 * 32 * 3\n",
    "hidden_size = 100\n",
    "num_classes = 10\n",
    "net = ShallowLayerNet(input_size, hidden_size, num_classes)\n",
    "\n",
    "# 训练网络\n",
    "stats = net.train(X_train, y_train, X_val, y_val,\n",
    "            num_iters=2000, batch_size=500,\n",
    "            learning_rate=1e-3, learning_rate_decay=0.95,\n",
    "            reg=0.6, verbose=True)\n",
    "\n",
    "# 验证结果\n",
    "val_acc =(net.predict(X_val) == y_val).mean()\n",
    "print('最终验证正确率: ', val_acc)\n",
    "print('历史最佳验证正确率: ', stats['best_val_acc'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "83b23111",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 绘制损失函数变化曲线\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.plot(stats['loss_history'])\n",
    "plt.title('Loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Loss')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(stats['train_acc_history'], label='train')\n",
    "plt.plot(stats['val_acc_history'], label='val')\n",
    "plt.plot([0.5] * len(stats['val_acc_history']), 'k--')\n",
    "plt.title('Classification accuracy history')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Clasification accuracy')\n",
    "# 添加图标\n",
    "plt.legend()\n",
    "# 控制布局\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff93000c",
   "metadata": {},
   "source": [
    "## 深层全连接网络\n",
    "\n",
    "接下来我们将实现深层的全连接网络，由于我们以及实现了浅层网络，深层网络的实现将变得很简单。\n",
    "\n",
    "深层神经网络相比于浅层神经网络，虽然仅仅是隐藏层数量变多而已，但它却具有了浅层网络没有的强大能力。由于我们已经实现了浅层网络，深层网络的实现将变得非常简单。现在要做的仅仅是将浅层网络中固定的单隐藏层变成任意多层即可。在深层全连接神经网络，隐藏层使用ReLU作为激活函数，输出层使用Softmax作为分类器。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "20f39adf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "权重衰减系数=  0\n",
      "初始化化损失值:  2.302159545825584\n",
      "W1 相对误差: 7.30e-07\n",
      "W2 相对误差: 1.58e-06\n",
      "W3 相对误差: 1.46e-05\n",
      "W4 相对误差: 2.62e-07\n",
      "b1 相对误差: 1.09e-07\n",
      "b2 相对误差: 6.68e-08\n",
      "b3 相对误差: 7.98e-09\n",
      "b4 相对误差: 1.66e-10\n",
      "权重衰减系数=  0.11\n",
      "初始化化损失值:  2.5476208798306548\n",
      "W1 相对误差: 2.01e-06\n",
      "W2 相对误差: 2.32e-06\n",
      "W3 相对误差: 2.71e-07\n",
      "W4 相对误差: 3.10e-07\n",
      "b1 相对误差: 5.28e-08\n",
      "b2 相对误差: 1.34e-07\n",
      "b3 相对误差: 1.14e-08\n",
      "b4 相对误差: 1.25e-10\n",
      "权重衰减系数=  3.14\n",
      "初始化化损失值:  8.634845503833256\n",
      "W1 相对误差: 8.14e-09\n",
      "W2 相对误差: 6.13e-07\n",
      "W3 相对误差: 4.64e-08\n",
      "W4 相对误差: 7.77e-06\n",
      "b1 相对误差: 1.01e-06\n",
      "b2 相对误差: 7.53e-08\n",
      "b3 相对误差: 1.53e-08\n",
      "b4 相对误差: 3.77e-10\n"
     ]
    }
   ],
   "source": [
    "N, D, H1, H2,H3, C = 2, 15, 20, 30, 20, 10\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=(N,))\n",
    "\n",
    "for reg in [0, 0.11, 3.14]:\n",
    "    print('权重衰减系数= ', reg)\n",
    "    model = FullyConnectedNet(input_dim=D,hidden_dims=[H1, H2,H3],num_classes=C,reg=reg, weight_scale=5e-2)\n",
    "\n",
    "    loss, grads = model.loss(X, y)\n",
    "    print('初始化化损失值: ', loss)\n",
    "\n",
    "    for name in sorted(grads):\n",
    "        f = lambda _: model.loss(X, y)[0]\n",
    "        grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n",
    "        print('%s 相对误差: %.2e' %(name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "af64be47",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 0 / 20: loss 1151.183192\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 在小数据集上测试训练效果，正常情况下应该出现严重过拟合现象\n",
    "input_size = 32 * 32 * 3\n",
    "num_classes = 10\n",
    "num_train = 50\n",
    "\n",
    "X_train_small= X_train[:num_train]\n",
    "y_train_small= y_train[:num_train]\n",
    "w= 1e-1\n",
    "l = 1e-3\n",
    "net = FullyConnectedNet(input_size ,[100,100,100,100,100] , num_classes, weight_scale=w ,reg=0.6)\n",
    "# 训练网络\n",
    "stats = net.train(X_train_small, y_train_small, X_val, y_val,\n",
    "            num_iters=20, batch_size=25,\n",
    "            learning_rate=l, learning_rate_decay=0.95,\n",
    "            verbose=True)\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.plot(stats['loss_history'],'o')\n",
    "plt.title('Loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Loss')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(stats['train_acc_history'], label='train')\n",
    "plt.plot(stats['val_acc_history'], label='val')\n",
    "plt.title('Classification accuracy history')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Clasification accuracy')\n",
    "# 添加图标\n",
    "plt.legend()\n",
    "# 控制布局\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "10dd0049",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "验证精度:  0.478\n",
      "最佳验证精度:  0.488\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "input_size = 32 * 32 * 3\n",
    "num_classes = 10\n",
    "net = FullyConnectedNet(input_size,[100,100],num_classes,reg=0.6,weight_scale=2e-2)\n",
    "# 训练网络\n",
    "stats = net.train(X_train, y_train, X_val, y_val,\n",
    "            num_iters=2000, batch_size=500,\n",
    "            learning_rate=8e-3, learning_rate_decay=0.95,\n",
    "            verbose=False)\n",
    "# 测试性能\n",
    "val_acc =(net.predict(X_val) == y_val).mean()\n",
    "print('验证精度: ', val_acc)\n",
    "print('最佳验证精度: ', stats['best_val_acc'])\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.plot(stats['loss_history'],'o')\n",
    "plt.title('Loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Loss')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(stats['train_acc_history'], label='train')\n",
    "plt.plot(stats['val_acc_history'], label='val')\n",
    "plt.title('Classification accuracy history')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Clasification accuracy')\n",
    "# 添加图标\n",
    "plt.legend()\n",
    "# 控制布局\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "415cb378",
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_1232/962960828.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     20\u001b[0m                     \u001b[0mnum_iters\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m1000\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbatch_size\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m500\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     21\u001b[0m                     \u001b[0mlearning_rate\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0ml\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlearning_rate_decay\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m0.95\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 22\u001b[1;33m                     verbose=False)\n\u001b[0m\u001b[0;32m     23\u001b[0m         \u001b[1;31m# 测试性能\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     24\u001b[0m         \u001b[0mval_acc\u001b[0m \u001b[1;33m=\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnet\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX_val\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0my_val\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\workspace\\Python\\jupyter\\深度学习实战范例\\DLAction\\classifiers\\chapter3\\fc_net.py\u001b[0m in \u001b[0;36mtrain\u001b[1;34m(self, X, y, X_val, y_val, learning_rate, learning_rate_decay, num_iters, batch_size, verbose)\u001b[0m\n\u001b[0;32m    134\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    135\u001b[0m             \u001b[1;31m#计算损失以及梯度\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 136\u001b[1;33m             \u001b[0mloss\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgrads\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mloss\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX_batch\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0my_batch\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    137\u001b[0m             \u001b[0mloss_history\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mloss\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    138\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\workspace\\Python\\jupyter\\深度学习实战范例\\DLAction\\classifiers\\chapter3\\fc_net.py\u001b[0m in \u001b[0;36mloss\u001b[1;34m(self, X, y)\u001b[0m\n\u001b[0;32m     92\u001b[0m             \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mh\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     93\u001b[0m                 dout[h-i-1], grads['W'+str(h-i)], grads['b'+str(h-i)] = affine_relu_backward(\n\u001b[1;32m---> 94\u001b[1;33m                     dout[h-i], cache_relu[h-i])\n\u001b[0m\u001b[0;32m     95\u001b[0m                 \u001b[0mgrads\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'W'\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0mstr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mh\u001b[0m\u001b[1;33m-\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreg\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'W'\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0mstr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mh\u001b[0m\u001b[1;33m-\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     96\u001b[0m         \u001b[1;31m############################################################################\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\workspace\\Python\\jupyter\\深度学习实战范例\\DLAction\\classifiers\\chapter3\\layers.py\u001b[0m in \u001b[0;36maffine_relu_backward\u001b[1;34m(dout, cache)\u001b[0m\n\u001b[0;32m    165\u001b[0m     \u001b[0mfc_cache\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrelu_cache\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcache\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    166\u001b[0m     \u001b[0mda\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mrelu_backward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdout\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mrelu_cache\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 167\u001b[1;33m     \u001b[0mdx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdw\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdb\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0maffine_backward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mda\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfc_cache\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    168\u001b[0m     \u001b[1;31m#############################################################################\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    169\u001b[0m     \u001b[1;31m#                                     结束编码                                                                                             #\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\workspace\\Python\\jupyter\\深度学习实战范例\\DLAction\\classifiers\\chapter3\\layers.py\u001b[0m in \u001b[0;36maffine_backward\u001b[1;34m(dout, cache)\u001b[0m\n\u001b[0;32m     65\u001b[0m     \u001b[1;31m# 将x重塑成(N, D)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     66\u001b[0m     \u001b[0mxx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 67\u001b[1;33m     \u001b[0mdw\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mxx\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mT\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdout\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     68\u001b[0m     \u001b[0mdx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdout\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mw\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mT\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     69\u001b[0m     \u001b[1;31m# 将dx的形状与x重塑成一样\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<__array_function__ internals>\u001b[0m in \u001b[0;36mdot\u001b[1;34m(*args, **kwargs)\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "best_net = None\n",
    "##########################################################################\n",
    "#               任务：尽可能训练一个最佳的深层神经网络                   #\n",
    "##########################################################################\n",
    "input_size = 32 * 32 * 3\n",
    "num_classes = 10\n",
    "\n",
    "# 进行探查\n",
    "lr = np.array([1e-3, 8e-3, 4e-3])\n",
    "ws = np.array([1e-2, 2e-2, 1e-1])\n",
    "# 记录最好的参数\n",
    "best_lr = 0.0\n",
    "best_ws = 0.0\n",
    "best_val_acc = 0.0\n",
    "\n",
    "for l in lr:\n",
    "    for w in ws:\n",
    "        net = FullyConnectedNet(input_size, [32*32, 320, 160, 32], num_classes, reg=0.6,weight_scale=w)\n",
    "        stats = net.train(X_train, y_train, X_val, y_val,\n",
    "                    num_iters=1000, batch_size=500,\n",
    "                    learning_rate=l, learning_rate_decay=0.95,\n",
    "                    verbose=False)\n",
    "        # 测试性能\n",
    "        val_acc =(net.predict(X_val) == y_val).mean()\n",
    "        if val_acc > best_val_acc:\n",
    "            best_net = net\n",
    "            best_lr = l\n",
    "            best_ws = w\n",
    "            best_val_acc = val_acc\n",
    "            \n",
    "print('验证学习率: ', best_lr)\n",
    "print('验证权重: ', best_ws)\n",
    "print('验证精度: ', val_acc)\n",
    "print('最佳验证精度: ', stats['best_val_acc'])\n",
    "\n",
    "##########################################################################\n",
    "#                      结束编码                                          #\n",
    "##########################################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c78a4cab",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_acc =(best_net.predict(X_test) ==y_test).mean()\n",
    "print('Test accuracy: ', test_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7de83643",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
